package com.cardcaptorsakura.model.dto;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

/**
 * 聊天响应DTO
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatResponse {

    /**
     * 请求ID
     */
    private String requestId;

    /**
     * 响应ID
     */
    private String responseId;

    /**
     * 用户ID
     */
    private String userId;

    /**
     * 会话ID
     */
    private String conversationId;

    /**
     * 生成的回复内容
     */
    private String content;

    /**
     * 响应状态
     */
    private ResponseStatus status;

    /**
     * 生成时间戳
     */
    private LocalDateTime timestamp;

    /**
     * 处理时间（毫秒）
     */
    private Long processingTimeMs;

    /**
     * 使用的模型信息
     */
    private String model;

    /**
     * 模型版本
     */
    private String modelVersion;

    /**
     * 生成参数
     */
    private GenerationParameters parameters;

    /**
     * Token使用统计
     */
    private TokenUsage tokenUsage;

    /**
     * 置信度评分（0-1）
     */
    private Double confidence;

    /**
     * 内容质量评分（0-100）
     */
    private Integer qualityScore;

    /**
     * 情感分析结果
     */
    private SentimentAnalysis sentiment;

    /**
     * 内容安全检查结果
     */
    private ContentSafetyResult contentSafety;

    /**
     * 关键词提取结果
     */
    private List<String> keywords;

    /**
     * 主题分类
     */
    private List<String> topics;

    /**
     * 意图识别结果
     */
    private IntentRecognition intent;

    /**
     * 错误信息
     */
    private String errorMessage;

    /**
     * 错误代码
     */
    private String errorCode;

    /**
     * 警告信息
     */
    private List<String> warnings;

    /**
     * 建议的后续操作
     */
    private List<String> suggestedActions;

    /**
     * 相关资源链接
     */
    private List<String> relatedResources;

    /**
     * 成本信息
     */
    private CostInfo costInfo;

    /**
     * 元数据
     */
    private Map<String, Object> metadata;

    /**
     * 是否被内容过滤修改
     */
    private Boolean contentFiltered;

    /**
     * 原始内容（如果被过滤）
     */
    private String originalContent;

    /**
     * 响应状态枚举
     */
    public enum ResponseStatus {
        SUCCESS,            // 成功
        PARTIAL_SUCCESS,    // 部分成功
        FAILED,             // 失败
        FILTERED,           // 被内容过滤
        RATE_LIMITED,       // 速率限制
        TIMEOUT,            // 超时
        MODEL_ERROR,        // 模型错误
        INVALID_REQUEST     // 无效请求
    }

    /**
     * 生成参数
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class GenerationParameters {
        /**
         * 温度参数
         */
        private Double temperature;

        /**
         * Top-p参数
         */
        private Double topP;

        /**
         * Top-k参数
         */
        private Integer topK;

        /**
         * 最大长度
         */
        private Integer maxLength;

        /**
         * 重复惩罚
         */
        private Double repetitionPenalty;

        /**
         * 停止词
         */
        private List<String> stopWords;

        /**
         * 种子值
         */
        private Long seed;

        /**
         * 是否流式输出
         */
        private Boolean stream;
    }

    /**
     * Token使用统计
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class TokenUsage {
        /**
         * 输入token数
         */
        private Integer promptTokens;

        /**
         * 输出token数
         */
        private Integer completionTokens;

        /**
         * 总token数
         */
        private Integer totalTokens;

        /**
         * 缓存命中的token数
         */
        private Integer cachedTokens;

        /**
         * Token使用率（0-1）
         */
        private Double utilizationRate;

        /**
         * 预估成本
         */
        private Double estimatedCost;

        /**
         * 货币单位
         */
        private String currency;
    }

    /**
     * 情感分析结果
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class SentimentAnalysis {
        /**
         * 整体情感（POSITIVE, NEGATIVE, NEUTRAL）
         */
        private String overall;

        /**
         * 积极情感分数（0-1）
         */
        private Double positiveScore;

        /**
         * 消极情感分数（0-1）
         */
        private Double negativeScore;

        /**
         * 中性情感分数（0-1）
         */
        private Double neutralScore;

        /**
         * 置信度（0-1）
         */
        private Double confidence;

        /**
         * 检测到的情感标签
         */
        private List<String> emotionLabels;

        /**
         * 情感强度（0-1）
         */
        private Double intensity;

        /**
         * 情感变化趋势
         */
        private String trend;
    }

    /**
     * 内容安全检查结果
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ContentSafetyResult {
        /**
         * 是否安全
         */
        private Boolean isSafe;

        /**
         * 风险级别（LOW, MEDIUM, HIGH）
         */
        private String riskLevel;

        /**
         * 检测到的问题类型
         */
        private List<String> detectedIssues;

        /**
         * 置信度（0-1）
         */
        private Double confidence;

        /**
         * 详细说明
         */
        private String description;

        /**
         * 建议操作
         */
        private String recommendedAction;

        /**
         * 过滤原因
         */
        private String filterReason;

        /**
         * 违规分数（0-100）
         */
        private Integer violationScore;
    }

    /**
     * 意图识别结果
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class IntentRecognition {
        /**
         * 识别到的意图
         */
        private String intent;

        /**
         * 意图置信度（0-1）
         */
        private Double confidence;

        /**
         * 意图分类
         */
        private String category;

        /**
         * 提取的实体
         */
        private Map<String, String> entities;

        /**
         * 意图参数
         */
        private Map<String, Object> parameters;

        /**
         * 建议的响应类型
         */
        private String suggestedResponseType;

        /**
         * 是否需要进一步澄清
         */
        private Boolean needsClarification;

        /**
         * 澄清问题
         */
        private List<String> clarificationQuestions;
    }

    /**
     * 成本信息
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public static class CostInfo {
        /**
         * 输入成本
         */
        private Double inputCost;

        /**
         * 输出成本
         */
        private Double outputCost;

        /**
         * 总成本
         */
        private Double totalCost;

        /**
         * 货币单位
         */
        private String currency;

        /**
         * 成本明细
         */
        private Map<String, Double> costBreakdown;

        /**
         * 计费模式
         */
        private String billingMode;

        /**
         * 折扣信息
         */
        private String discountInfo;
    }

    /**
     * 检查响应是否成功
     */
    public boolean isSuccess() {
        return status == ResponseStatus.SUCCESS || status == ResponseStatus.PARTIAL_SUCCESS;
    }

    /**
     * 检查响应是否失败
     */
    public boolean isFailed() {
        return status == ResponseStatus.FAILED || 
               status == ResponseStatus.TIMEOUT || 
               status == ResponseStatus.MODEL_ERROR || 
               status == ResponseStatus.INVALID_REQUEST;
    }

    /**
     * 检查内容是否被过滤
     */
    public boolean isContentFiltered() {
        return status == ResponseStatus.FILTERED || 
               (contentFiltered != null && contentFiltered);
    }

    /**
     * 检查是否被速率限制
     */
    public boolean isRateLimited() {
        return status == ResponseStatus.RATE_LIMITED;
    }

    /**
     * 获取处理时间（秒）
     */
    public double getProcessingTimeSeconds() {
        return processingTimeMs != null ? processingTimeMs / 1000.0 : 0.0;
    }

    /**
     * 获取内容长度
     */
    public int getContentLength() {
        return content != null ? content.length() : 0;
    }

    /**
     * 获取单词数量
     */
    public int getWordCount() {
        if (content == null || content.trim().isEmpty()) {
            return 0;
        }
        return content.trim().split("\\s+").length;
    }

    /**
     * 获取句子数量
     */
    public int getSentenceCount() {
        if (content == null || content.trim().isEmpty()) {
            return 0;
        }
        return content.split("[.!?]+").length;
    }

    /**
     * 获取状态描述
     */
    public String getStatusDescription() {
        if (status == null) return "未知";
        
        switch (status) {
            case SUCCESS:
                return "成功";
            case PARTIAL_SUCCESS:
                return "部分成功";
            case FAILED:
                return "失败";
            case FILTERED:
                return "内容被过滤";
            case RATE_LIMITED:
                return "速率限制";
            case TIMEOUT:
                return "超时";
            case MODEL_ERROR:
                return "模型错误";
            case INVALID_REQUEST:
                return "无效请求";
            default:
                return "未知状态";
        }
    }

    /**
     * 获取质量等级
     */
    public String getQualityGrade() {
        if (qualityScore == null) return "未评估";
        
        if (qualityScore >= 90) return "优秀";
        if (qualityScore >= 80) return "良好";
        if (qualityScore >= 70) return "一般";
        if (qualityScore >= 60) return "及格";
        return "较差";
    }

    /**
     * 获取情感描述
     */
    public String getSentimentDescription() {
        if (sentiment == null || sentiment.getOverall() == null) {
            return "未分析";
        }
        
        switch (sentiment.getOverall().toUpperCase()) {
            case "POSITIVE":
                return "积极";
            case "NEGATIVE":
                return "消极";
            case "NEUTRAL":
                return "中性";
            default:
                return "未知";
        }
    }

    /**
     * 获取安全等级描述
     */
    public String getSafetyDescription() {
        if (contentSafety == null || !contentSafety.getIsSafe()) {
            return "不安全";
        }
        
        if (contentSafety.getRiskLevel() == null) {
            return "安全";
        }
        
        switch (contentSafety.getRiskLevel().toUpperCase()) {
            case "LOW":
                return "低风险";
            case "MEDIUM":
                return "中等风险";
            case "HIGH":
                return "高风险";
            default:
                return "安全";
        }
    }

    /**
     * 获取响应摘要
     */
    public String getResponseSummary() {
        return String.format("状态: %s, 长度: %d字符, 处理时间: %.2f秒, 质量: %s",
                getStatusDescription(),
                getContentLength(),
                getProcessingTimeSeconds(),
                getQualityGrade());
    }

    /**
     * 获取Token效率
     */
    public double getTokenEfficiency() {
        if (tokenUsage == null || tokenUsage.getTotalTokens() == null || tokenUsage.getTotalTokens() == 0) {
            return 0.0;
        }
        
        int contentLength = getContentLength();
        if (contentLength == 0) {
            return 0.0;
        }
        
        return (double) contentLength / tokenUsage.getTotalTokens();
    }

    /**
     * 检查是否需要人工审核
     */
    public boolean needsHumanReview() {
        // 内容安全风险较高
        if (contentSafety != null && "HIGH".equals(contentSafety.getRiskLevel())) {
            return true;
        }
        
        // 质量分数较低
        if (qualityScore != null && qualityScore < 60) {
            return true;
        }
        
        // 置信度较低
        if (confidence != null && confidence < 0.7) {
            return true;
        }
        
        // 有警告信息
        if (warnings != null && !warnings.isEmpty()) {
            return true;
        }
        
        return false;
    }

    /**
     * 创建成功响应
     */
    public static ChatResponse success(String content) {
        return ChatResponse.builder()
                .content(content)
                .status(ResponseStatus.SUCCESS)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 创建失败响应
     */
    public static ChatResponse failure(String errorMessage, String errorCode) {
        return ChatResponse.builder()
                .status(ResponseStatus.FAILED)
                .errorMessage(errorMessage)
                .errorCode(errorCode)
                .timestamp(LocalDateTime.now())
                .build();
    }

    /**
     * 创建被过滤响应
     */
    public static ChatResponse filtered(String reason) {
        return ChatResponse.builder()
                .status(ResponseStatus.FILTERED)
                .errorMessage("内容被安全过滤器拦截")
                .errorCode("CONTENT_FILTERED")
                .timestamp(LocalDateTime.now())
                .build();
    }
}